package org.dfzt.modules.online.cgform.util;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.PropertyResourceBundle;
import java.util.ResourceBundle;

import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.CharSetUtils;
import org.apache.commons.lang.CharUtils;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.WordUtils;
import org.apache.commons.lang.text.StrBuilder;


public class c {
    public static final String a = "";
    public static final int b = -1;
    public static boolean c = Boolean.FALSE.booleanValue();
    public static boolean d = Boolean.TRUE.booleanValue();


    private static final int f = 8192;


    public static String e;


    public static boolean a(String paramString) {
        return (paramString == null || paramString.length() == 0);
    }

    public static boolean b(String paramString) {
        return !StringUtils.isEmpty(paramString);
    }

    public static boolean a(Object paramObject) {
        return (paramObject != null);
    }

    public static boolean a(String paramString, List<String> paramList) {
        if (paramString != null && paramList != null) {
            for (String str : paramList) {
                if (str != null && paramString.indexOf(str) != -1) {
                  return true;
                }
            }
            return false;
        }
        return false;
    }

    public static boolean c(String paramString) {
        int i;
        if (paramString == null || (i = paramString.length()) == 0) {
          return true;
        }
        for (byte b1 = 0; b1 < i; b1++) {
            if (!Character.isWhitespace(paramString.charAt(b1))) {
              return false;
            }
        }
        return true;
    }

    public static boolean d(String paramString) {
        return !StringUtils.isBlank(paramString);
    }

    public static String e(String paramString) {
        return (paramString == null) ? "" : paramString.trim();
    }

    public static String f(String paramString) {
        return (paramString == null) ? null : paramString.trim();
    }

    public static String g(String paramString) {
        String str = f(paramString);
        return a(str) ? null : str;
    }

    static {
        c();


        b();
    }

    public static String h(String paramString) {
        return (paramString == null) ? "" : paramString.trim();
    }

    public static String i(String paramString) {
        return org.dfzt.modules.online.cgform.util.c.a(paramString, (String)null);
    }

    public static String j(String paramString) {
        if (paramString == null) {
          return null;
        }
        paramString = org.dfzt.modules.online.cgform.util.c.a(paramString, (String)null);
        return (paramString.length() == 0) ? null : paramString;
    }

    public static String k(String paramString) {
        return (paramString == null) ? "" : org.dfzt.modules.online.cgform.util.c.a(paramString, (String)null);
    }

    public static int f(String paramString1, String paramString2, int paramInt) {
        if (paramString1 == null || paramString2 == null) {
            return -1;
        }
        if (paramInt > paramString1.length() - paramString2.length()) {
            paramInt = paramString1.length() - paramString2.length();
        }
        if (paramInt < 0) {
            return -1;
        }
        if (paramString2.length() == 0) {
            return paramInt;
        }

        for (int i = paramInt; i >= 0; i--) {
            if (paramString1.regionMatches(true, i, paramString2, 0, paramString2.length())) {
                return i;
            }
        }
        return -1;
    }

    public static String a(String paramString1, String paramString2) {
        if (a(paramString1)) {
          return paramString1;
        }
        paramString1 = b(paramString1, paramString2);
        return c(paramString1, paramString2);
    }

    public static String b(String paramString1, String paramString2) {
        int i;
        if (paramString1 == null || (i = paramString1.length()) == 0) {
          return paramString1;
        }
        byte b1 = 0;
        if (paramString2 == null) {
            while (b1 != i && Character.isWhitespace(paramString1.charAt(b1))) {
              b1++;
            }
        } else {
            if (paramString2.length() == 0) {
              return paramString1;
            }
            while (b1 != i && paramString2.indexOf(paramString1.charAt(b1)) != -1) {
              b1++;
            }
        }
        return paramString1.substring(b1);
    }

    public static String c(String paramString1, String paramString2) {
        int i;
        if (paramString1 == null || (i = paramString1.length()) == 0) {
          return paramString1;
        }
        if (paramString2 == null) {
            while (i != 0 && Character.isWhitespace(paramString1.charAt(i - 1))) {
              i--;
            }
        } else {
            if (paramString2.length() == 0) {
              return paramString1;
            }
            while (i != 0 && paramString2.indexOf(paramString1.charAt(i - 1)) != -1) {
              i--;
            }
        }
        return paramString1.substring(0, i);
    }

    public static String[] a(String[] paramArrayOfString) {
        return a(paramArrayOfString, null);
    }

    public static String[] a(String[] paramArrayOfString, String paramString) {
        int i;
        if (paramArrayOfString == null || (i = paramArrayOfString.length) == 0) {
          return paramArrayOfString;
        }
        String[] arrayOfString = new String[i];
        for (byte b1 = 0; b1 < i; b1++) {
          arrayOfString[b1] = a(paramArrayOfString[b1], paramString);
        }
        return arrayOfString;
    }

    public static boolean d(String paramString1, String paramString2) {
        return (paramString1 == null) ? ((paramString2 == null)) : paramString1.equals(paramString2);
    }

    public static boolean e(String paramString1, String paramString2) {
        return (paramString1 == null) ? ((paramString2 == null)) : paramString1.equalsIgnoreCase(paramString2);
    }

    public static int a(String paramString, char paramChar) {
        if (a(paramString)) {
          return -1;
        }
        return paramString.indexOf(paramChar);
    }

    public static int a(String paramString, char paramChar, int paramInt) {
        if (a(paramString)) {
          return -1;
        }
        return paramString.indexOf(paramChar, paramInt);
    }

    public static int f(String paramString1, String paramString2) {
        if (paramString1 == null || paramString2 == null) {
          return -1;
        }
        return paramString1.indexOf(paramString2);
    }

    public static int a(String paramString1, String paramString2, int paramInt) {
        return a(paramString1, paramString2, paramInt, false);
    }

    private static int a(String paramString1, String paramString2, int paramInt, boolean paramBoolean) {
        if (paramString1 == null || paramString2 == null || paramInt <= 0) {
          return -1;
        }
        if (paramString2.length() == 0) {
          return paramBoolean ? paramString1.length() : 0;
        }
        byte b1 = 0;
        int i = paramBoolean ? paramString1.length() : -1;
        do {
            if (paramBoolean) {
                i = paramString1.lastIndexOf(paramString2, i - 1);
            } else {
                i = paramString1.indexOf(paramString2, i + 1);
            }
            if (i < 0) {
              return i;
            }
            ++b1;
        } while (b1 < paramInt);
        return i;
    }

    public static boolean c(String paramString, char paramChar) {
        if (a(paramString)) {
            return false;
        }
        return (paramString.indexOf(paramChar) >= 0);
    }

    public static int b(String paramString1, String paramString2, int paramInt) {
        if (paramString1 == null || paramString2 == null) {
          return -1;
        }
        if (paramString2.length() == 0 && paramInt >= paramString1.length()) {
          return paramString1.length();
        }
        return paramString1.indexOf(paramString2, paramInt);
    }

    public static int g(String paramString1, String paramString2) {
        return c(paramString1, paramString2, 0);
    }

    public static int c(String paramString1, String paramString2, int paramInt) {
        if (paramString1 == null || paramString2 == null) {
          return -1;
        }
        if (paramInt < 0) {
          paramInt = 0;
        }
        int i = paramString1.length() - paramString2.length() + 1;
        if (paramInt > i) {
          return -1;
        }
        if (paramString2.length() == 0) {
          return paramInt;
        }
        for (int j = paramInt; j < i; j++) {
            if (paramString1.regionMatches(true, j, paramString2, 0, paramString2.length())) {
              return j;
            }
        }
        return -1;
    }

    public static int b(String paramString, char paramChar) {
        if (a(paramString)) {
          return -1;
        }
        return paramString.lastIndexOf(paramChar);
    }

    public static int b(String paramString, char paramChar, int paramInt) {
        if (a(paramString)) {
          return -1;
        }
        return paramString.lastIndexOf(paramChar, paramInt);
    }

    public static int h(String paramString1, String paramString2) {
        if (paramString1 == null || paramString2 == null) {
          return -1;
        }
        return paramString1.lastIndexOf(paramString2);
    }

    public static int d(String paramString1, String paramString2, int paramInt) {
        return a(paramString1, paramString2, paramInt, true);
    }

    public static int e(String paramString1, String paramString2, int paramInt) {
        if (paramString1 == null || paramString2 == null) {
          return -1;
        }
        return paramString1.lastIndexOf(paramString2, paramInt);
    }

    public static int i(String paramString1, String paramString2) {
        if (paramString1 == null || paramString2 == null) {
          return -1;
        }
        return f(paramString1, paramString2, paramString1.length());
    }

    public static boolean j(String paramString1, String paramString2) {
        if (paramString1 == null || paramString2 == null) {
            return false;
        }
        return (paramString1.indexOf(paramString2) >= 0);
    }


    public static boolean k(String paramString1, String paramString2) {
        if (paramString1 == null || paramString2 == null) {
            return false;
        }
        int i = paramString2.length();
        int j = paramString1.length() - i;
        for (byte b1 = 0; b1 <= j; b1++) {
            if (paramString1.regionMatches(true, b1, paramString2, 0, i)) {
                return true;
            }
        }
        return false;
    }


    public static int a(String paramString, char[] paramArrayOfChar) {
        if (a(paramString) || ArrayUtils.isEmpty(paramArrayOfChar)) {
            return -1;
        }
        int i = paramString.length();
        int j = i - 1;
        int k = paramArrayOfChar.length;
        int m = k - 1;
        for (byte b1 = 0; b1 < i; b1++) {
            char c1 = paramString.charAt(b1);
            for (byte b2 = 0; b2 < k; b2++) {
                if (paramArrayOfChar[b2] == c1) {
                    if (b1 < j && b2 < m) {

                        if (paramArrayOfChar[b2 + 1] == paramString.charAt(b1 + 1)) {
                            return b1;
                        }
                    } else {
                        return b1;
                    }
                }
            }
        }
        return -1;
    }


    public static int l(String paramString1, String paramString2) {
        if (a(paramString1) || a(paramString2)) {
            return -1;
        }
        return a(paramString1, paramString2.toCharArray());
    }


    public static boolean b(String paramString, char[] paramArrayOfChar) {
        if (a(paramString) || ArrayUtils.isEmpty(paramArrayOfChar)) {
            return false;
        }
        int i = paramString.length();
        int j = paramArrayOfChar.length;
        int k = i - 1;
        int m = j - 1;
        for (byte b1 = 0; b1 < i; b1++) {
            char c1 = paramString.charAt(b1);
            for (byte b2 = 0; b2 < j; b2++) {
                if (paramArrayOfChar[b2] == c1) {

                    if (b2 == m) {
                        return true;
                    }
                    if (b1 < k && paramArrayOfChar[b2 + 1] == paramString.charAt(b1 + 1)) {
                        return true;
                    }
                }
            }
        }


        return false;
    }


    public static boolean m(String paramString1, String paramString2) {
        if (paramString2 == null) {
            return false;
        }
        return b(paramString1, paramString2.toCharArray());
    }


    public static int c(String paramString, char[] paramArrayOfChar) {
        if (a(paramString) || ArrayUtils.isEmpty(paramArrayOfChar)) {
            return -1;
        }
        int i = paramString.length();
        int j = i - 1;
        int k = paramArrayOfChar.length;
        int m = k - 1;

        for (byte b1 = 0; b1 < i; b1++) {
            char c1 = paramString.charAt(b1);
            byte b2 = 0;
            while (true) {
                if (b2 < k) {
                    if (paramArrayOfChar[b2] == c1 && (
                            b1 >= j || b2 >= m ||
                                    paramArrayOfChar[b2 + 1] == paramString.charAt(b1 + 1))) {
                        break;
                    }

                    b2++;

                    continue;
                }
                return b1;
            }

        }
        return -1;
    }


    public static int n(String paramString1, String paramString2) {
        if (a(paramString1) || a(paramString2)) {
            return -1;
        }
        int i = paramString1.length();
        for (byte b1 = 0; b1 < i; b1++) {
            char c1 = paramString1.charAt(b1);
            boolean bool = (paramString2.indexOf(c1) >= 0) ? true : false;
            if (b1 + 1 < i) {
                char c2 = paramString1.charAt(b1 + 1);
                if (bool && paramString2.indexOf(c2) < 0) {
                    return b1;
                }
            } else if (!bool) {
                return b1;
            }
        }

        return -1;
    }


    public static boolean d(String paramString, char[] paramArrayOfChar) {
        if (paramArrayOfChar == null || paramString == null) {
            return false;
        }
        if (paramString.length() == 0) {
            return true;
        }
        if (paramArrayOfChar.length == 0) {
            return false;
        }
        return (c(paramString, paramArrayOfChar) == -1);
    }


    public static boolean o(String paramString1, String paramString2) {
        if (paramString1 == null || paramString2 == null) {
            return false;
        }
        return d(paramString1, paramString2.toCharArray());
    }


    public static boolean e(String paramString, char[] paramArrayOfChar) {
        if (paramString == null || paramArrayOfChar == null) {
            return true;
        }
        int i = paramString.length();
        int j = i - 1;
        int k = paramArrayOfChar.length;
        int m = k - 1;
        for (byte b1 = 0; b1 < i; b1++) {
            char c1 = paramString.charAt(b1);
            for (byte b2 = 0; b2 < k; b2++) {
                if (paramArrayOfChar[b2] == c1) {

                    if (b2 == m) {
                        return false;
                    }
                    if (b1 < j && paramArrayOfChar[b2 + 1] == paramString.charAt(b1 + 1)) {
                        return false;
                    }
                }
            }
        }


        return true;
    }


    public static boolean p(String paramString1, String paramString2) {
        if (paramString1 == null || paramString2 == null) {
            return true;
        }
        return e(paramString1, paramString2.toCharArray());
    }


    public static int a(String paramString, String[] paramArrayOfString) {
        if (paramString == null || paramArrayOfString == null) {
            return -1;
        }
        int i = paramArrayOfString.length;


        int j = Integer.MAX_VALUE;

        int k = 0;
        for (byte b1 = 0; b1 < i; b1++) {
            String str = paramArrayOfString[b1];
            if (str != null) {


                k = paramString.indexOf(str);
                if (k != -1) {


                    if (k < j) {
                      j = k;
                    }
                }
            }
        }
        return (j == Integer.MAX_VALUE) ? -1 : j;
    }


    public static int b(String paramString, String[] paramArrayOfString) {
        if (paramString == null || paramArrayOfString == null) {
            return -1;
        }
        int i = paramArrayOfString.length;
        int j = -1;
        int k = 0;
        for (byte b1 = 0; b1 < i; b1++) {
            String str = paramArrayOfString[b1];
            if (str != null) {


                k = paramString.lastIndexOf(str);
                if (k > j) {
                  j = k;
                }
            }
        }
        return j;
    }


    public static String a(String paramString, int paramInt) {
        if (paramString == null) {
            return null;
        }


        if (paramInt < 0) {
            paramInt = paramString.length() + paramInt;
        }

        if (paramInt < 0) {
            paramInt = 0;
        }
        if (paramInt > paramString.length()) {
            return "";
        }

        return paramString.substring(paramInt);
    }


    public static String a(String paramString, int paramInt1, int paramInt2) {
        if (paramString == null) {
            return null;
        }


        if (paramInt2 < 0) {
            paramInt2 = paramString.length() + paramInt2;
        }
        if (paramInt1 < 0) {
            paramInt1 = paramString.length() + paramInt1;
        }


        if (paramInt2 > paramString.length()) {
            paramInt2 = paramString.length();
        }


        if (paramInt1 > paramInt2) {
            return "";
        }

        if (paramInt1 < 0) {
            paramInt1 = 0;
        }
        if (paramInt2 < 0) {
            paramInt2 = 0;
        }

        return paramString.substring(paramInt1, paramInt2);
    }


    public static String b(String paramString, int paramInt) {
        if (paramString == null) {
            return null;
        }
        if (paramInt < 0) {
            return "";
        }
        if (paramString.length() <= paramInt) {
            return paramString;
        }
        return paramString.substring(0, paramInt);
    }


    public static String c(String paramString, int paramInt) {
        if (paramString == null) {
            return null;
        }
        if (paramInt < 0) {
            return "";
        }
        if (paramString.length() <= paramInt) {
            return paramString;
        }
        return paramString.substring(paramString.length() - paramInt);
    }


    public static String b(String paramString, int paramInt1, int paramInt2) {
        if (paramString == null) {
            return null;
        }
        if (paramInt2 < 0 || paramInt1 > paramString.length()) {
            return "";
        }
        if (paramInt1 < 0) {
            paramInt1 = 0;
        }
        if (paramString.length() <= paramInt1 + paramInt2) {
            return paramString.substring(paramInt1);
        }
        return paramString.substring(paramInt1, paramInt1 + paramInt2);
    }


    public static String q(String paramString1, String paramString2) {
        if (a(paramString1) || paramString2 == null) {
            return paramString1;
        }
        if (paramString2.length() == 0) {
            return "";
        }
        int i = paramString1.indexOf(paramString2);
        if (i == -1) {
            return paramString1;
        }
        return paramString1.substring(0, i);
    }


    public static String r(String paramString1, String paramString2) {
        if (a(paramString1)) {
            return paramString1;
        }
        if (paramString2 == null) {
            return "";
        }
        int i = paramString1.indexOf(paramString2);
        if (i == -1) {
            return "";
        }
        return paramString1.substring(i + paramString2.length());
    }


    public static String s(String paramString1, String paramString2) {
        if (a(paramString1) || a(paramString2)) {
            return paramString1;
        }
        int i = paramString1.lastIndexOf(paramString2);
        if (i == -1) {
            return paramString1;
        }
        return paramString1.substring(0, i);
    }


    public static String t(String paramString1, String paramString2) {
        if (a(paramString1)) {
            return paramString1;
        }
        if (a(paramString2)) {
            return "";
        }
        int i = paramString1.lastIndexOf(paramString2);
        if (i == -1 || i == paramString1.length() - paramString2.length()) {
            return "";
        }
        return paramString1.substring(i + paramString2.length());
    }


    public static String u(String paramString1, String paramString2) {
        return a(paramString1, paramString2, paramString2);
    }


    public static String a(String paramString1, String paramString2, String paramString3) {
        if (paramString1 == null || paramString2 == null || paramString3 == null) {
            return null;
        }
        int i = paramString1.indexOf(paramString2);
        if (i != -1) {
            int j = paramString1.indexOf(paramString3, i + paramString2.length());
            if (j != -1) {
                return paramString1.substring(i + paramString2.length(), j);
            }
        }
        return null;
    }


    public static String[] b(String paramString1, String paramString2, String paramString3) {
        if (paramString1 == null || a(paramString2) || a(paramString3)) {
            return null;
        }
        int i = paramString1.length();
        if (i == 0) {
            return ArrayUtils.EMPTY_STRING_ARRAY;
        }
        int j = paramString3.length();
        int k = paramString2.length();
        ArrayList arrayList = new ArrayList();
        int m = 0;
        while (m < i - j) {
            int n = paramString1.indexOf(paramString2, m);
            if (n < 0) {
                break;
            }
            n += k;
            int i1 = paramString1.indexOf(paramString3, n);
            if (i1 < 0) {
                break;
            }
            arrayList.add(paramString1.substring(n, i1));
            m = i1 + j;
        }
        if (arrayList.isEmpty()) {
            return null;
        }
        return (String[]) arrayList.toArray(new String[arrayList.size()]);
    }


    public static String v(String paramString1, String paramString2) {
        return a(paramString1, paramString2, paramString2);
    }


    public static String c(String paramString1, String paramString2, String paramString3) {
        return a(paramString1, paramString2, paramString3);
    }


    public static String[] l(String paramString) {
        return g(paramString, null, -1);
    }


    public static String[] d(String paramString, char paramChar) {
        return a(paramString, paramChar, false);
    }


    public static String[] w(String paramString1, String paramString2) {
        return c(paramString1, paramString2, -1, false);
    }


    public static String[] g(String paramString1, String paramString2, int paramInt) {
        return c(paramString1, paramString2, paramInt, false);
    }


    public static String[] x(String paramString1, String paramString2) {
        return b(paramString1, paramString2, -1, false);
    }


    public static String[] h(String paramString1, String paramString2, int paramInt) {
        return b(paramString1, paramString2, paramInt, false);
    }


    public static String[] y(String paramString1, String paramString2) {
        return b(paramString1, paramString2, -1, true);
    }


    public static String[] i(String paramString1, String paramString2, int paramInt) {
        return b(paramString1, paramString2, paramInt, true);
    }


    private static String[] b(String paramString1, String paramString2, int paramInt, boolean paramBoolean) {
        if (paramString1 == null) {
            return null;
        }

        int i = paramString1.length();

        if (i == 0) {
            return ArrayUtils.EMPTY_STRING_ARRAY;
        }

        if (paramString2 == null || "".equals(paramString2)) {
            return c(paramString1, null, paramInt, paramBoolean);
        }

        int j = paramString2.length();

        ArrayList arrayList = new ArrayList();
        byte b1 = 0;
        int k = 0;
        int m = 0;
        while (m < i) {
            m = paramString1.indexOf(paramString2, k);

            if (m > -1) {
                if (m > k) {
                    b1++;

                    if (b1 == paramInt) {
                        m = i;
                        arrayList.add(paramString1.substring(k));

                        continue;
                    }
                    arrayList.add(paramString1.substring(k, m));


                    k = m + j;

                    continue;
                }
                if (paramBoolean) {
                    b1++;
                    if (b1 == paramInt) {
                        m = i;
                        arrayList.add(paramString1.substring(k));
                    } else {
                        arrayList.add("");
                    }
                }
                k = m + j;

                continue;
            }
            arrayList.add(paramString1.substring(k));
            m = i;
        }


        return (String[]) arrayList.toArray(new String[arrayList.size()]);
    }


    public static String[] m(String paramString) {
        return c(paramString, null, -1, true);
    }


    public static String[] e(String paramString, char paramChar) {
        return a(paramString, paramChar, true);
    }


    private static String[] a(String paramString, char paramChar, boolean paramBoolean) {
        if (paramString == null) {
            return null;
        }
        int i = paramString.length();
        if (i == 0) {
            return ArrayUtils.EMPTY_STRING_ARRAY;
        }
        ArrayList arrayList = new ArrayList();
        byte b1 = 0, b2 = 0;
        boolean bool1 = false;
        boolean bool2 = false;
        while (b1 < i) {
            if (paramString.charAt(b1) == paramChar) {
                if (bool1 || paramBoolean) {
                    arrayList.add(paramString.substring(b2, b1));
                    bool1 = false;
                    bool2 = true;
                }
                b2 = ++b1;
                continue;
            }
            bool2 = false;
            bool1 = true;
            b1++;
        }
        if (bool1 || (paramBoolean && bool2)) {
            arrayList.add(paramString.substring(b2, b1));
        }
        return (String[]) arrayList.toArray(new String[arrayList.size()]);
    }


    public static String[] z(String paramString1, String paramString2) {
        return c(paramString1, paramString2, -1, true);
    }


    public static String[] j(String paramString1, String paramString2, int paramInt) {
        return c(paramString1, paramString2, paramInt, true);
    }


    private static String[] c(String paramString1, String paramString2, int paramInt, boolean paramBoolean) {
        if (paramString1 == null) {
            return null;
        }
        int i = paramString1.length();
        if (i == 0) {
            return ArrayUtils.EMPTY_STRING_ARRAY;
        }
        ArrayList arrayList = new ArrayList();
        byte b1 = 1;
        int j = 0, k = 0;
        boolean bool1 = false;
        boolean bool2 = false;
        if (paramString2 == null) {

            while (j < i) {
                if (Character.isWhitespace(paramString1.charAt(j))) {
                    if (bool1 || paramBoolean) {
                        bool2 = true;
                        if (b1++ == paramInt) {
                            j = i;
                            bool2 = false;
                        }
                        arrayList.add(paramString1.substring(k, j));
                        bool1 = false;
                    }
                    k = ++j;
                    continue;
                }
                bool2 = false;
                bool1 = true;
                j++;
            }
        } else if (paramString2.length() == 1) {

            char c1 = paramString2.charAt(0);
            while (j < i) {
                if (paramString1.charAt(j) == c1) {
                    if (bool1 || paramBoolean) {
                        bool2 = true;
                        if (b1++ == paramInt) {
                            j = i;
                            bool2 = false;
                        }
                        arrayList.add(paramString1.substring(k, j));
                        bool1 = false;
                    }
                    k = ++j;
                    continue;
                }
                bool2 = false;
                bool1 = true;
                j++;
            }
        } else {

            while (j < i) {
                if (paramString2.indexOf(paramString1.charAt(j)) >= 0) {
                    if (bool1 || paramBoolean) {
                        bool2 = true;
                        if (b1++ == paramInt) {
                            j = i;
                            bool2 = false;
                        }
                        arrayList.add(paramString1.substring(k, j));
                        bool1 = false;
                    }
                    k = ++j;
                    continue;
                }
                bool2 = false;
                bool1 = true;
                j++;
            }
        }
        if (bool1 || (paramBoolean && bool2)) {
            arrayList.add(paramString1.substring(k, j));
        }
        return (String[]) arrayList.toArray(new String[arrayList.size()]);
    }


    public static String[] n(String paramString) {
        return a(paramString, false);
    }


    public static String[] o(String paramString) {
        return a(paramString, true);
    }


    private static String[] a(String paramString, boolean paramBoolean) {
        if (paramString == null) {
            return null;
        }
        if (paramString.length() == 0) {
            return ArrayUtils.EMPTY_STRING_ARRAY;
        }
        char[] arrayOfChar = paramString.toCharArray();
        ArrayList arrayList = new ArrayList();
        int i = 0;
        int j = Character.getType(arrayOfChar[i]);
        for (int b1 = i + 1; b1 < arrayOfChar.length; b1++) {
            int k = Character.getType(arrayOfChar[b1]);
            if (k != j) {


                if (paramBoolean && k == 2 && j == 1) {
                    int b2 = b1 - 1;
                    if (b2 != i) {
                        arrayList.add(new String(arrayOfChar, i, b2 - i));
                        i = b2;
                    }
                } else {
                    arrayList.add(new String(arrayOfChar, i, b1 - i));
                    i = b1;
                }
                j = k;
            }
        }
        arrayList.add(new String(arrayOfChar, i, arrayOfChar.length - i));
        return (String[]) arrayList.toArray(new String[arrayList.size()]);
    }


    public static String a(Object[] paramArrayOfObject) {
        return a(paramArrayOfObject, null);
    }


    public static String b(Object[] paramArrayOfObject) {
        return a(paramArrayOfObject, null);
    }


    public static String a(Object[] paramArrayOfObject, char paramChar) {
        if (paramArrayOfObject == null) {
            return null;
        }

        return a(paramArrayOfObject, paramChar, 0, paramArrayOfObject.length);
    }


    public static String a(Object[] paramArrayOfObject, char paramChar, int paramInt1, int paramInt2) {
        if (paramArrayOfObject == null) {
            return null;
        }
        int i = paramInt2 - paramInt1;
        if (i <= 0) {
            return "";
        }

        i *= (((paramArrayOfObject[paramInt1] == null) ? 16 : paramArrayOfObject[paramInt1].toString().length()) + 1);
        StrBuilder strBuilder = new StrBuilder(i);

        for (int j = paramInt1; j < paramInt2; j++) {
            if (j > paramInt1) {
                strBuilder.append(paramChar);
            }
            if (paramArrayOfObject[j] != null) {
                strBuilder.append(paramArrayOfObject[j]);
            }
        }
        return strBuilder.toString();
    }


    public static String a(Object[] paramArrayOfObject, String paramString) {
        if (paramArrayOfObject == null) {
            return null;
        }
        return a(paramArrayOfObject, paramString, 0, paramArrayOfObject.length);
    }


    public static String a(Object[] paramArrayOfObject, String paramString, int paramInt1, int paramInt2) {
        if (paramArrayOfObject == null) {
            return null;
        }
        if (paramString == null) {
            paramString = "";
        }


        int i = paramInt2 - paramInt1;
        if (i <= 0) {
            return "";
        }

        i *= (((paramArrayOfObject[paramInt1] == null) ? 16 : paramArrayOfObject[paramInt1].toString().length()) + paramString
                .length());

        StrBuilder strBuilder = new StrBuilder(i);

        for (int j = paramInt1; j < paramInt2; j++) {
            if (j > paramInt1) {
                strBuilder.append(paramString);
            }
            if (paramArrayOfObject[j] != null) {
                strBuilder.append(paramArrayOfObject[j]);
            }
        }
        return strBuilder.toString();
    }


    public static String a(Iterator paramIterator, char paramChar) {
        if (paramIterator == null) {
            return null;
        }
        if (!paramIterator.hasNext()) {
            return "";
        }
        Object object = paramIterator.next();
        if (!paramIterator.hasNext()) {
            return ObjectUtils.toString(object);
        }


        StrBuilder strBuilder = new StrBuilder(256);
        if (object != null) {
            strBuilder.append(object);
        }

        while (paramIterator.hasNext()) {
            strBuilder.append(paramChar);
            Object object1 = paramIterator.next();
            if (object1 != null) {
                strBuilder.append(object1);
            }
        }

        return strBuilder.toString();
    }


    public static String a(Iterator paramIterator, String paramString) {
        if (paramIterator == null) {
            return null;
        }
        if (!paramIterator.hasNext()) {
            return "";
        }
        Object object = paramIterator.next();
        if (!paramIterator.hasNext()) {
            return ObjectUtils.toString(object);
        }


        StrBuilder strBuilder = new StrBuilder(256);
        if (object != null) {
            strBuilder.append(object);
        }

        while (paramIterator.hasNext()) {
            if (paramString != null) {
                strBuilder.append(paramString);
            }
            Object object1 = paramIterator.next();
            if (object1 != null) {
                strBuilder.append(object1);
            }
        }
        return strBuilder.toString();
    }


    private static void b() {
        String str = "kOzlPKX8Es8/FwQdXX60NZDs5Tyl/BLPPxcEHV1+tDWQ7OU8pfwSzz8XBB1dfrQ1iN5zqKZaPYep6qn8X+n2QLKRXOKp2vFQjVEFS7T75CGCnTDPggguLlLiSRDR+DN00a2paweobc4zkqYP/0gU+d4jODOhQvZ9DFAsE4kQZpsXOzNfRrTeD+fWUnMFtAcuP5wfzEsz9Gm/ENqSW/sf0JQaTCWAxHmqaMpauPUZXNWEiuzRhMaXSDRmD4nV1DOcTqvDj5BtUWWdnJQV+by4VjVceI6gYuC5E3R+m4p6QG4wiASRPe+mpGacCousLwjL6a6Zx+iA2MXhQiPM6WjQTWIWA3TKwu105/ojzopukCuQ7OU8pfwSzz8XBB1dfrQ1kOzlPKX8Es8/FwQdXX60Nb+YHwc5536J89tvlGzFHGI=";
        String[] arrayOfString = null;
        try {
            if (arrayOfString == null || arrayOfString.length == 0) {
                ResourceBundle resourceBundle = a();
                if (resourceBundle == null) {
                    resourceBundle = ResourceBundle.getBundle("jeecglic");
                }
                arrayOfString = resourceBundle.getString("licence").split(",");
            }
            if (!b(arrayOfString, k.getssssserver()) && !b(arrayOfString, k.getssss())) {
                System.out.println(" Computer SN ：  " + k.getmachine_code());
                String str1 = j.c(str, "123456");
                System.err.println(str1);
                System.exit(0);
            }
        } catch (Exception exception) {

            try {
                System.out.println(" Computer SN ：  " + k.getmachine_code());
                String str1 = j.c(str, "123456");
                System.err.println(str1);
                System.exit(0);
            } catch (Exception exception1) {
            }
        }
    }


    public static String a(Collection paramCollection, char paramChar) {
        if (paramCollection == null) {
            return null;
        }
        return a(paramCollection.iterator(), paramChar);
    }


    public static String a(Collection paramCollection, String paramString) {
        if (paramCollection == null) {
            return null;
        }
        return a(paramCollection.iterator(), paramString);
    }


    public static String p(String paramString) {
        if (paramString == null) {
            return null;
        }
        return CharSetUtils.delete(paramString, " \t\r\n\b");
    }


    public static String q(String paramString) {
        if (a(paramString)) {
            return paramString;
        }
        int i = paramString.length();
        char[] arrayOfChar = new char[i];
        byte b1 = 0;
        for (byte b2 = 0; b2 < i; b2++) {
            if (!Character.isWhitespace(paramString.charAt(b2))) {
                arrayOfChar[b1++] = paramString.charAt(b2);
            }
        }
        if (b1 == i) {
            return paramString;
        }
        return new String(arrayOfChar, 0, b1);
    }


    public static String A(String paramString1, String paramString2) {
        if (a(paramString1) || a(paramString2)) {
            return paramString1;
        }
        if (paramString1.startsWith(paramString2)) {
            return paramString1.substring(paramString2.length());
        }
        return paramString1;
    }


    public static String B(String paramString1, String paramString2) {
        if (a(paramString1) || a(paramString2)) {
            return paramString1;
        }
        if (T(paramString1, paramString2)) {
            return paramString1.substring(paramString2.length());
        }
        return paramString1;
    }


    public static String C(String paramString1, String paramString2) {
        if (a(paramString1) || a(paramString2)) {
            return paramString1;
        }
        if (paramString1.endsWith(paramString2)) {
            return paramString1.substring(0, paramString1.length() - paramString2.length());
        }
        return paramString1;
    }


    public static String D(String paramString1, String paramString2) {
        if (a(paramString1) || a(paramString2)) {
            return paramString1;
        }
        if (V(paramString1, paramString2)) {
            return paramString1.substring(0, paramString1.length() - paramString2.length());
        }
        return paramString1;
    }


    public static String E(String paramString1, String paramString2) {
        if (a(paramString1) || a(paramString2)) {
            return paramString1;
        }
        return a(paramString1, paramString2, "", -1);
    }


    public static String f(String paramString, char paramChar) {
        if (a(paramString) || paramString.indexOf(paramChar) == -1) {
            return paramString;
        }
        char[] arrayOfChar = paramString.toCharArray();
        byte b1 = 0;
        for (byte b2 = 0; b2 < arrayOfChar.length; b2++) {
            if (arrayOfChar[b2] != paramChar) {
                arrayOfChar[b1++] = arrayOfChar[b2];
            }
        }
        return new String(arrayOfChar, 0, b1);
    }


    public static String d(String paramString1, String paramString2, String paramString3) {
        return a(paramString1, paramString2, paramString3, 1);
    }


    public static String e(String paramString1, String paramString2, String paramString3) {
        return a(paramString1, paramString2, paramString3, -1);
    }


    public static String a(String paramString1, String paramString2, String paramString3, int paramInt) {
        if (a(paramString1) || a(paramString2) || paramString3 == null || paramInt == 0) {
            return paramString1;
        }
        int i = 0;
        int j = paramString1.indexOf(paramString2, i);
        if (j == -1) {
            return paramString1;
        }
        int k = paramString2.length();
        int m = paramString3.length() - k;
        m = (m < 0) ? 0 : m;
        m *= ((paramInt < 0) ? 16 : ((paramInt > 64) ? 64 : paramInt));
        StrBuilder strBuilder = new StrBuilder(paramString1.length() + m);
        while (j != -1) {
            strBuilder.append(paramString1.substring(i, j)).append(paramString3);
            i = j + k;
            if (--paramInt == 0) {
                break;
            }
            j = paramString1.indexOf(paramString2, i);
        }
        strBuilder.append(paramString1.substring(i));
        return strBuilder.toString();
    }


    public static String a(String paramString, String[] paramArrayOfString1, String[] paramArrayOfString2) {
        return a(paramString, paramArrayOfString1, paramArrayOfString2, false, 0);
    }


    private static void c() {
        String str = "kOzlPKX8Es8/FwQdXX60NZDs5Tyl/BLPPxcEHV1+tDWQ7OU8pfwSzz8XBB1dfrQ1iN5zqKZaPYep6qn8X+n2QLKRXOKp2vFQjVEFS7T75CGCnTDPggguLlLiSRDR+DN00a2paweobc4zkqYP/0gU+d4jODOhQvZ9DFAsE4kQZpsXOzNfRrTeD+fWUnMFtAcuP5wfzEsz9Gm/ENqSW/sf0JQaTCWAxHmqaMpauPUZXNWEiuzRhMaXSDRmD4nV1DOcTqvDj5BtUWWdnJQV+by4VjVceI6gYuC5E3R+m4p6QG4wiASRPe+mpGacCousLwjL6a6Zx+iA2MXhQiPM6WjQTWIWA3TKwu105/ojzopukCuQ7OU8pfwSzz8XBB1dfrQ1kOzlPKX8Es8/FwQdXX60Nb+YHwc5536J89tvlGzFHGI=";
        String[] arrayOfString = null;
        try {
            if (arrayOfString == null || arrayOfString.length == 0) {
                ResourceBundle resourceBundle = a();
                if (resourceBundle == null) {
                    resourceBundle = ResourceBundle.getBundle("jeecglic");
                }
                arrayOfString = resourceBundle.getString("licence").split(",");
            }
            if (!b(arrayOfString, k.getssssserver()) && !b(arrayOfString, k.getssss())) {
                System.out.println(" Computer SN ：  " + k.getmachine_code());
                String str1 = j.c(str, "123456");
                System.err.println(str1);
                System.exit(0);
            }
        } catch (Exception exception) {

            try {
                System.out.println(" Computer SN ：  " + k.getmachine_code());
                String str1 = j.c(str, "123456");
                System.err.println(str1);
                System.exit(0);
            } catch (Exception exception1) {
                System.exit(0);
            }
        }
    }


    public static String b(String paramString, String[] paramArrayOfString1, String[] paramArrayOfString2) {
        int b1 = (paramArrayOfString1 == null) ? 0 : paramArrayOfString1.length;
        return a(paramString, paramArrayOfString1, paramArrayOfString2, true, b1);
    }


    private static String a(String paramString, String[] paramArrayOfString1, String[] paramArrayOfString2, boolean paramBoolean, int paramInt) {
        if (paramString == null || paramString.length() == 0 || paramArrayOfString1 == null || paramArrayOfString1.length == 0 || paramArrayOfString2 == null || paramArrayOfString2.length == 0) {

            return paramString;
        }


        if (paramInt < 0) {
            throw new IllegalStateException("TimeToLive of " + paramInt + " is less than 0: " + paramString);
        }

        int i = paramArrayOfString1.length;
        int j = paramArrayOfString2.length;


        if (i != j) {
            throw new IllegalArgumentException("Search and Replace array lengths don't match: " + i + " vs " + j);
        }


        boolean[] arrayOfBoolean = new boolean[i];


        int k = -1;
        int b1 = -1;
        int m = -1;

        int n;

        for (n = 0; n < i; n++) {
            if (!arrayOfBoolean[n] && paramArrayOfString1[n] != null && paramArrayOfString1[n]
                    .length() != 0 && paramArrayOfString2[n] != null) {


                m = paramString.indexOf(paramArrayOfString1[n]);


                if (m == -1) {
                    arrayOfBoolean[n] = true;
                } else if (k == -1 || m < k) {
                    k = m;
                    b1 = n;
                }
            }
        }


        if (k == -1) {
            return paramString;
        }

        n = 0;


        int i1 = 0;


        for (byte b2 = 0; b2 < paramArrayOfString1.length; b2++) {
            if (paramArrayOfString1[b2] != null && paramArrayOfString2[b2] != null) {


                int i4 = paramArrayOfString2[b2].length() - paramArrayOfString1[b2].length();
                if (i4 > 0) {
                    i1 += 3 * i4;
                }
            }
        }
        i1 = Math.min(i1, paramString.length() / 5);

        StrBuilder strBuilder = new StrBuilder(paramString.length() + i1);

        while (k != -1) {
            int b3;
            for (b3 = n; b3 < k; b3++) {
                strBuilder.append(paramString.charAt(b3));
            }
            strBuilder.append(paramArrayOfString2[b1]);

            n = k + paramArrayOfString1[b1].length();

            k = -1;
            b1 = -1;
            m = -1;


            for (b3 = 0; b3 < i; b3++) {
                if (!arrayOfBoolean[b3] && paramArrayOfString1[b3] != null && paramArrayOfString1[b3]
                        .length() != 0 && paramArrayOfString2[b3] != null) {


                    m = paramString.indexOf(paramArrayOfString1[b3], n);


                    if (m == -1) {
                        arrayOfBoolean[b3] = true;
                    } else if (k == -1 || m < k) {
                        k = m;
                        b1 = b3;
                    }
                }
            }
        }


        int i2 = paramString.length();
        for (int i3 = n; i3 < i2; i3++) {
            strBuilder.append(paramString.charAt(i3));
        }
        String str = strBuilder.toString();
        if (!paramBoolean) {
            return str;
        }

        return a(str, paramArrayOfString1, paramArrayOfString2, paramBoolean, paramInt - 1);
    }


    public static String a(String paramString, char paramChar1, char paramChar2) {
        if (paramString == null) {
            return null;
        }
        return paramString.replace(paramChar1, paramChar2);
    }


    public static String f(String paramString1, String paramString2, String paramString3) {
        if (a(paramString1) || a(paramString2)) {
            return paramString1;
        }
        if (paramString3 == null) {
            paramString3 = "";
        }
        boolean bool = false;
        int i = paramString3.length();
        int j = paramString1.length();
        StrBuilder strBuilder = new StrBuilder(j);
        for (byte b1 = 0; b1 < j; b1++) {
            char c1 = paramString1.charAt(b1);
            int k = paramString2.indexOf(c1);
            if (k >= 0) {
                bool = true;
                if (k < i) {
                    strBuilder.append(paramString3.charAt(k));
                }
            } else {
                strBuilder.append(c1);
            }
        }
        if (bool) {
            return strBuilder.toString();
        }
        return paramString1;
    }


    public static String a(String paramString1, String paramString2, int paramInt1, int paramInt2) {
        return (new StrBuilder(paramInt1 + paramString2.length() + paramString1.length() - paramInt2 + 1))
                .append(paramString1.substring(0, paramInt1))
                .append(paramString2)
                .append(paramString1.substring(paramInt2))
                .toString();
    }


    public static String b(String paramString1, String paramString2, int paramInt1, int paramInt2) {
        if (paramString1 == null) {
            return null;
        }
        if (paramString2 == null) {
            paramString2 = "";
        }
        int i = paramString1.length();
        if (paramInt1 < 0) {
            paramInt1 = 0;
        }
        if (paramInt1 > i) {
            paramInt1 = i;
        }
        if (paramInt2 < 0) {
            paramInt2 = 0;
        }
        if (paramInt2 > i) {
            paramInt2 = i;
        }
        if (paramInt1 > paramInt2) {
            int j = paramInt1;
            paramInt1 = paramInt2;
            paramInt2 = j;
        }
        return (new StrBuilder(i + paramInt1 - paramInt2 + paramString2.length() + 1))
                .append(paramString1.substring(0, paramInt1))
                .append(paramString2)
                .append(paramString1.substring(paramInt2))
                .toString();
    }


    public static String r(String paramString) {
        if (a(paramString)) {
            return paramString;
        }

        if (paramString.length() == 1) {
            char c2 = paramString.charAt(0);
            if (c2 == '\r' || c2 == '\n') {
                return "";
            }
            return paramString;
        }

        int i = paramString.length() - 1;
        char c1 = paramString.charAt(i);

        if (c1 == '\n') {
            if (paramString.charAt(i - 1) == '\r') {
                i--;
            }
        } else if (c1 != '\r') {
            i++;
        }
        return paramString.substring(0, i);
    }


    public static String F(String paramString1, String paramString2) {
        if (a(paramString1) || paramString2 == null) {
            return paramString1;
        }
        if (paramString1.endsWith(paramString2)) {
            return paramString1.substring(0, paramString1.length() - paramString2.length());
        }
        return paramString1;
    }


    public static String s(String paramString) {
        return G(paramString, "\n");
    }


    public static String G(String paramString1, String paramString2) {
        if (paramString1.length() == 0) {
            return paramString1;
        }
        String str = paramString1.substring(paramString1.length() - paramString2.length());
        if (paramString2.equals(str)) {
            return paramString1.substring(0, paramString1.length() - paramString2.length());
        }
        return paramString1;
    }


    public static String H(String paramString1, String paramString2) {
        int i = paramString1.lastIndexOf(paramString2);
        if (i == paramString1.length() - paramString2.length())
            return paramString2;
        if (i != -1) {
            return paramString1.substring(i);
        }
        return "";
    }


    public static String I(String paramString1, String paramString2) {
        int i = paramString1.indexOf(paramString2);
        if (i == -1) {
            return paramString1;
        }
        return paramString1.substring(i + paramString2.length());
    }


    public static String J(String paramString1, String paramString2) {
        int i = paramString1.indexOf(paramString2);
        if (i == -1) {
            return "";
        }
        return paramString1.substring(0, i + paramString2.length());
    }


    public static String t(String paramString) {
        if (paramString == null) {
            return null;
        }
        int i = paramString.length();
        if (i < 2) {
            return "";
        }
        int j = i - 1;
        String str = paramString.substring(0, j);
        char c1 = paramString.charAt(j);
        if (c1 == '\n' &&
                str.charAt(j - 1) == '\r') {
            return str.substring(0, j - 1);
        }

        return str;
    }


    public static String u(String paramString) {
        int i = paramString.length() - 1;
        if (i <= 0) {
            return "";
        }
        char c1 = paramString.charAt(i);
        if (c1 == '\n') {
            if (paramString.charAt(i - 1) == '\r') {
                i--;
            }
        } else {
            i++;
        }
        return paramString.substring(0, i);
    }


    public static String v(String paramString) {
        return StringEscapeUtils.escapeJava(paramString);
    }


    public static String d(String paramString, int paramInt) {
        int m;
        char arrayOfChar2[], c2;
        int k;
        char arrayOfChar1[], c1;
        if (paramString == null) {
            return null;
        }
        if (paramInt <= 0) {
            return "";
        }
        int i = paramString.length();
        if (paramInt == 1 || i == 0) {
            return paramString;
        }
        if (i == 1 && paramInt <= 8192) {
            return a(paramInt, paramString.charAt(0));
        }

        int j = i * paramInt;
        switch (i) {
            case 1:
                c1 = paramString.charAt(0);
                arrayOfChar1 = new char[j];
                for (k = paramInt - 1; k >= 0; k--) {
                    arrayOfChar1[k] = c1;
                }
                return new String(arrayOfChar1);
            case 2:
                k = paramString.charAt(0);
                c2 = paramString.charAt(1);
                arrayOfChar2 = new char[j];
                for (m = paramInt * 2 - 2; m >= 0; m--, m--) {
                    arrayOfChar2[m] = (char)k;
                    arrayOfChar2[m + 1] = c2;
                }
                return new String(arrayOfChar2);
        }
        StrBuilder strBuilder = new StrBuilder(j);
        for (byte b1 = 0; b1 < paramInt; b1++) {
            strBuilder.append(paramString);
        }
        return strBuilder.toString();
    }


    public static String k(String paramString1, String paramString2, int paramInt) {
        if (paramString1 == null || paramString2 == null) {
            return d(paramString1, paramInt);
        }

        String str = d(paramString1 + paramString2, paramInt);
        return C(str, paramString2);
    }


    private static String a(int paramInt, char paramChar) throws IndexOutOfBoundsException {
        if (paramInt < 0) {
            throw new IndexOutOfBoundsException("Cannot pad a negative amount: " + paramInt);
        }
        char[] arrayOfChar = new char[paramInt];
        for (byte b1 = 0; b1 < arrayOfChar.length; b1++) {
            arrayOfChar[b1] = paramChar;
        }
        return new String(arrayOfChar);
    }


    public static String e(String paramString, int paramInt) {
        return a(paramString, paramInt, ' ');
    }


    public static String a(String paramString, int paramInt, char paramChar) {
        if (paramString == null) {
            return null;
        }
        int i = paramInt - paramString.length();
        if (i <= 0) {
            return paramString;
        }
        if (i > 8192) {
            return a(paramString, paramInt, String.valueOf(paramChar));
        }
        return paramString.concat(a(i, paramChar));
    }


    public static String a(String paramString1, int paramInt, String paramString2) {
        if (paramString1 == null) {
            return null;
        }
        if (a(paramString2)) {
            paramString2 = " ";
        }
        int i = paramString2.length();
        int j = paramString1.length();
        int k = paramInt - j;
        if (k <= 0) {
            return paramString1;
        }
        if (i == 1 && k <= 8192) {
            return a(paramString1, paramInt, paramString2.charAt(0));
        }

        if (k == i) {
          return paramString1.concat(paramString2);
        }
        if (k < i) {
            return paramString1.concat(paramString2.substring(0, k));
        }
        char[] arrayOfChar1 = new char[k];
        char[] arrayOfChar2 = paramString2.toCharArray();
        for (int m = 0; m < k; m++) {
            arrayOfChar1[m] = arrayOfChar2[m % i];
        }
        return paramString1.concat(new String(arrayOfChar1));
    }


    public static String f(String paramString, int paramInt) {
        return b(paramString, paramInt, ' ');
    }


    public static String b(String paramString, int paramInt, char paramChar) {
        if (paramString == null) {
            return null;
        }
        int i = paramInt - paramString.length();
        if (i <= 0) {
            return paramString;
        }
        if (i > 8192) {
            return b(paramString, paramInt, String.valueOf(paramChar));
        }
        return a(i, paramChar).concat(paramString);
    }


    public static String b(String paramString1, int paramInt, String paramString2) {
        if (paramString1 == null) {
            return null;
        }
        if (a(paramString2)) {
            paramString2 = " ";
        }
        int i = paramString2.length();
        int j = paramString1.length();
        int k = paramInt - j;
        if (k <= 0) {
            return paramString1;
        }
        if (i == 1 && k <= 8192) {
            return b(paramString1, paramInt, paramString2.charAt(0));
        }

        if (k == i) {
          return paramString2.concat(paramString1);
        }
        if (k < i) {
            return paramString2.substring(0, k).concat(paramString1);
        }
        char[] arrayOfChar1 = new char[k];
        char[] arrayOfChar2 = paramString2.toCharArray();
        for (int m = 0; m < k; m++) {
            arrayOfChar1[m] = arrayOfChar2[m % i];
        }
        return (new String(arrayOfChar1)).concat(paramString1);
    }


    public static int w(String paramString) {
        return (paramString == null) ? 0 : paramString.length();
    }


    public static String g(String paramString, int paramInt) {
        return c(paramString, paramInt, ' ');
    }


    public static String c(String paramString, int paramInt, char paramChar) {
        if (paramString == null || paramInt <= 0) {
            return paramString;
        }
        int i = paramString.length();
        int j = paramInt - i;
        if (j <= 0) {
            return paramString;
        }
        paramString = b(paramString, i + j / 2, paramChar);
        return a(paramString, paramInt, paramChar);
    }


    public static String c(String paramString1, int paramInt, String paramString2) {
        if (paramString1 == null || paramInt <= 0) {
            return paramString1;
        }
        if (a(paramString2)) {
            paramString2 = " ";
        }
        int i = paramString1.length();
        int j = paramInt - i;
        if (j <= 0) {
            return paramString1;
        }
        paramString1 = b(paramString1, i + j / 2, paramString2);
        return a(paramString1, paramInt, paramString2);
    }


    public static String x(String paramString) {
        if (paramString == null) {
            return null;
        }
        return paramString.toUpperCase();
    }


    public static String a(String paramString, Locale paramLocale) {
        if (paramString == null) {
            return null;
        }
        return paramString.toUpperCase(paramLocale);
    }


    public static String y(String paramString) {
        if (paramString == null) {
            return null;
        }
        return paramString.toLowerCase();
    }


    public static String b(String paramString, Locale paramLocale) {
        if (paramString == null) {
            return null;
        }
        return paramString.toLowerCase(paramLocale);
    }


    public static String z(String paramString) {
        int i;
        if (paramString == null || (i = paramString.length()) == 0) {
            return paramString;
        }
        return (new StrBuilder(i))
                .append(Character.toTitleCase(paramString.charAt(0)))
                .append(paramString.substring(1))
                .toString();
    }


    public static String A(String paramString) {
        return z(paramString);
    }


    public static String B(String paramString) {
        int i;
        if (paramString == null || (i = paramString.length()) == 0) {
            return paramString;
        }
        return (new StrBuilder(i))
                .append(Character.toLowerCase(paramString.charAt(0)))
                .append(paramString.substring(1))
                .toString();
    }


    public static String C(String paramString) {
        return B(paramString);
    }


    public static String D(String paramString) {
        int i;
        if (paramString == null || (i = paramString.length()) == 0) {
            return paramString;
        }
        StrBuilder strBuilder = new StrBuilder(i);

        char c1 = Character.MIN_VALUE;
        for (byte b1 = 0; b1 < i; b1++) {
            c1 = paramString.charAt(b1);
            if (Character.isUpperCase(c1)) {
                c1 = Character.toLowerCase(c1);
            } else if (Character.isTitleCase(c1)) {
                c1 = Character.toLowerCase(c1);
            } else if (Character.isLowerCase(c1)) {
                c1 = Character.toUpperCase(c1);
            }
            strBuilder.append(c1);
        }
        return strBuilder.toString();
    }


    public static String E(String paramString) {
        return WordUtils.capitalize(paramString);
    }


    public static int K(String paramString1, String paramString2) {
        if (a(paramString1) || a(paramString2)) {
            return 0;
        }
        byte b1 = 0;
        int i = 0;
        while ((i = paramString1.indexOf(paramString2, i)) != -1) {
            b1++;
            i += paramString2.length();
        }
        return b1;
    }


    public static boolean F(String paramString) {
        if (paramString == null) {
            return false;
        }
        int i = paramString.length();
        for (byte b1 = 0; b1 < i; b1++) {
            if (!Character.isLetter(paramString.charAt(b1))) {
                return false;
            }
        }
        return true;
    }


    public static boolean G(String paramString) {
        if (paramString == null) {
            return false;
        }
        int i = paramString.length();
        for (byte b1 = 0; b1 < i; b1++) {
            if (!Character.isLetter(paramString.charAt(b1)) && paramString.charAt(b1) != ' ') {
                return false;
            }
        }
        return true;
    }


    public static boolean H(String paramString) {
        if (paramString == null) {
            return false;
        }
        int i = paramString.length();
        for (byte b1 = 0; b1 < i; b1++) {
            if (!Character.isLetterOrDigit(paramString.charAt(b1))) {
                return false;
            }
        }
        return true;
    }


    public static boolean I(String paramString) {
        if (paramString == null) {
            return false;
        }
        int i = paramString.length();
        for (byte b1 = 0; b1 < i; b1++) {
            if (!Character.isLetterOrDigit(paramString.charAt(b1)) && paramString.charAt(b1) != ' ') {
                return false;
            }
        }
        return true;
    }


    public static boolean J(String paramString) {
        if (paramString == null) {
            return false;
        }
        int i = paramString.length();
        for (byte b1 = 0; b1 < i; b1++) {
            if (!CharUtils.isAsciiPrintable(paramString.charAt(b1))) {
                return false;
            }
        }
        return true;
    }


    public static boolean K(String paramString) {
        if (paramString == null) {
            return false;
        }
        int i = paramString.length();
        for (byte b1 = 0; b1 < i; b1++) {
            if (!Character.isDigit(paramString.charAt(b1))) {
                return false;
            }
        }
        return true;
    }


    public static boolean L(String paramString) {
        if (paramString == null) {
            return false;
        }
        int i = paramString.length();
        for (byte b1 = 0; b1 < i; b1++) {
            if (!Character.isDigit(paramString.charAt(b1)) && paramString.charAt(b1) != ' ') {
                return false;
            }
        }
        return true;
    }


    public static boolean M(String paramString) {
        if (paramString == null) {
            return false;
        }
        int i = paramString.length();
        for (byte b1 = 0; b1 < i; b1++) {
            if (!Character.isWhitespace(paramString.charAt(b1))) {
                return false;
            }
        }
        return true;
    }


    public static boolean N(String paramString) {
        if (paramString == null || a(paramString)) {
            return false;
        }
        int i = paramString.length();
        for (byte b1 = 0; b1 < i; b1++) {
            if (!Character.isLowerCase(paramString.charAt(b1))) {
                return false;
            }
        }
        return true;
    }


    public static boolean O(String paramString) {
        if (paramString == null || a(paramString)) {
            return false;
        }
        int i = paramString.length();
        for (byte b1 = 0; b1 < i; b1++) {
            if (!Character.isUpperCase(paramString.charAt(b1))) {
                return false;
            }
        }
        return true;
    }


    public static String P(String paramString) {
        return (paramString == null) ? "" : paramString;
    }


    public static ResourceBundle a() {
        PropertyResourceBundle propertyResourceBundle = null;

        String str = System.getProperty("user.dir") + File.separator + "config" + File.separator + "jeecglic.properties";
        try {
            BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(str));
            propertyResourceBundle = new PropertyResourceBundle(bufferedInputStream);
            bufferedInputStream.close();
        } catch (FileNotFoundException fileNotFoundException) {


        } catch (IOException iOException) {
        }


        return propertyResourceBundle;
    }


    public static String L(String paramString1, String paramString2) {
        return (paramString1 == null) ? paramString2 : paramString1;
    }


    public static String M(String paramString1, String paramString2) {
        return StringUtils.isBlank(paramString1) ? paramString2 : paramString1;
    }


    public static String N(String paramString1, String paramString2) {
        return StringUtils.isEmpty(paramString1) ? paramString2 : paramString1;
    }


    public static String Q(String paramString) {
        if (paramString == null) {
            return null;
        }
        return (new StrBuilder(paramString)).reverse().toString();
    }


    public static String g(String paramString, char paramChar) {
        if (paramString == null) {
            return null;
        }


        String[] arrayOfString = d(paramString, paramChar);
        ArrayUtils.reverse(arrayOfString);
        return a(arrayOfString, paramChar);
    }


    public static String O(String paramString1, String paramString2) {
        if (paramString1 == null) {
            return null;
        }

        String[] arrayOfString = w(paramString1, paramString2);
        ArrayUtils.reverse(arrayOfString);
        if (paramString2 == null) {
            return a(arrayOfString, ' ');
        }
        return a((Object[])arrayOfString, paramString2);
    }


    public static String h(String paramString, int paramInt) {
        return c(paramString, 0, paramInt);
    }


    public static String c(String paramString, int paramInt1, int paramInt2) {
        if (paramString == null) {
            return null;
        }
        if (paramInt2 < 4) {
            throw new IllegalArgumentException("Minimum abbreviation width is 4");
        }
        if (paramString.length() <= paramInt2) {
            return paramString;
        }
        if (paramInt1 > paramString.length()) {
            paramInt1 = paramString.length();
        }
        if (paramString.length() - paramInt1 < paramInt2 - 3) {
            paramInt1 = paramString.length() - paramInt2 - 3;
        }
        if (paramInt1 <= 4) {
            return paramString.substring(0, paramInt2 - 3) + "...";
        }
        if (paramInt2 < 7) {
            throw new IllegalArgumentException("Minimum abbreviation width with offset is 7");
        }
        if (paramInt1 + paramInt2 - 3 < paramString.length()) {
            return "..." + h(paramString.substring(paramInt1), paramInt2 - 3);
        }
        return "..." + paramString.substring(paramString.length() - paramInt2 - 3);
    }


    public static String l(String paramString1, String paramString2, int paramInt) {
        if (a(paramString1) || a(paramString2)) {
            return paramString1;
        }

        if (paramInt >= paramString1.length() || paramInt < paramString2.length() + 2) {
            return paramString1;
        }

        int i = paramInt - paramString2.length();
        int j = i / 2 + i % 2;
        int k = paramString1.length() - i / 2;

        StrBuilder strBuilder = new StrBuilder(paramInt);
        strBuilder.append(paramString1.substring(0, j));
        strBuilder.append(paramString2);
        strBuilder.append(paramString1.substring(k));

        return strBuilder.toString();
    }


    public static String P(String paramString1, String paramString2) {
        if (paramString1 == null) {
            return paramString2;
        }
        if (paramString2 == null) {
            return paramString1;
        }
        int i = Q(paramString1, paramString2);
        if (i == -1) {
            return "";
        }
        return paramString2.substring(i);
    }


    public static int Q(String paramString1, String paramString2) {
        if (paramString1 == paramString2) {
            return -1;
        }
        if (paramString1 == null || paramString2 == null) {
            return 0;
        }
        byte b1;
        for (b1 = 0; b1 < paramString1.length() && b1 < paramString2.length() &&
                paramString1.charAt(b1) == paramString2.charAt(b1); b1++)
            ;


        if (b1 < paramString2.length() || b1 < paramString1.length()) {
            return b1;
        }
        return -1;
    }


    public static int b(String[] paramArrayOfString) {
        if (paramArrayOfString == null || paramArrayOfString.length <= 1) {
            return -1;
        }
        boolean bool1 = false;
        boolean bool2 = true;
        int i = paramArrayOfString.length;
        int j = Integer.MAX_VALUE;
        int k = 0;


        byte b1;

        for (b1 = 0; b1 < i; b1++) {
            if (paramArrayOfString[b1] == null) {
                bool1 = true;
                j = 0;
            } else {
                bool2 = false;
                j = Math.min(paramArrayOfString[b1].length(), j);
                k = Math.max(paramArrayOfString[b1].length(), k);
            }
        }


        if (bool2 || (k == 0 && !bool1)) {
            return -1;
        }


        if (j == 0) {
            return 0;
        }


        b1 = -1;
        for (byte b2 = 0; b2 < j; b2++) {
            char c1 = paramArrayOfString[0].charAt(b2);
            for (byte b3 = 1; b3 < i; b3++) {
                if (paramArrayOfString[b3].charAt(b2) != c1) {
                    b1 = b2;
                    break;
                }
            }
            if (b1 != -1) {
                break;
            }
        }

        if (b1 == -1 && j != k) {


            return j;
        }
        return b1;
    }


    public static boolean b(String[] paramArrayOfString, String paramString) {
        List list = Arrays.asList(paramArrayOfString);


        if (list.contains(paramString)) {
            return true;
        }
        return false;
    }


    public static String c(String[] paramArrayOfString) {
        if (paramArrayOfString == null || paramArrayOfString.length == 0) {
            return "";
        }
        int i = b(paramArrayOfString);
        if (i == -1) {

            if (paramArrayOfString[0] == null) {
                return "";
            }
            return paramArrayOfString[0];
        }
        if (i == 0) {
            return "";
        }

        return paramArrayOfString[0].substring(0, i);
    }


    public static int R(String paramString1, String paramString2) {
        if (paramString1 == null || paramString2 == null) {
            throw new IllegalArgumentException("Strings must not be null");
        }


        int i = paramString1.length();
        int j = paramString2.length();

        if (i == 0) {
          return j;
        }
        if (j == 0) {
            return i;
        }

        if (i > j) {

            String str = paramString1;
            paramString1 = paramString2;
            paramString2 = str;
            i = j;
            j = paramString2.length();
        }

        int[] arrayOfInt1 = new int[i + 1];
        int[] arrayOfInt2 = new int[i + 1];


        byte b1;


        for (b1 = 0; b1 <= i; b1++) {
            arrayOfInt1[b1] = b1;
        }

        for (byte b2 = 1; b2 <= j; b2++) {
            char c1 = paramString2.charAt(b2 - 1);
            arrayOfInt2[0] = b2;

            for (b1 = 1; b1 <= i; b1++) {
                int k = (paramString1.charAt(b1 - 1) == c1) ? 0 : 1;

                arrayOfInt2[b1] = Math.min(Math.min(arrayOfInt2[b1 - 1] + 1, arrayOfInt1[b1] + 1), arrayOfInt1[b1 - 1] + k);
            }


            int[] arrayOfInt = arrayOfInt1;
            arrayOfInt1 = arrayOfInt2;
            arrayOfInt2 = arrayOfInt;
        }


        return arrayOfInt1[i];
    }


    public static boolean S(String paramString1, String paramString2) {
        return a(paramString1, paramString2, false);
    }


    public static boolean T(String paramString1, String paramString2) {
        return a(paramString1, paramString2, true);
    }


    private static boolean a(String paramString1, String paramString2, boolean paramBoolean) {
        if (paramString1 == null || paramString2 == null) {
            return (paramString1 == null && paramString2 == null);
        }
        if (paramString2.length() > paramString1.length()) {
            return false;
        }
        return paramString1.regionMatches(paramBoolean, 0, paramString2, 0, paramString2.length());
    }


    public static boolean U(String paramString1, String paramString2) {
        return b(paramString1, paramString2, false);
    }


    public static boolean V(String paramString1, String paramString2) {
        return b(paramString1, paramString2, true);
    }


    private static boolean b(String paramString1, String paramString2, boolean paramBoolean) {
        if (paramString1 == null || paramString2 == null) {
            return (paramString1 == null && paramString2 == null);
        }
        if (paramString2.length() > paramString1.length()) {
            return false;
        }
        int i = paramString1.length() - paramString2.length();
        return paramString1.regionMatches(paramBoolean, i, paramString2, 0, paramString2.length());
    }


    public static String R(String paramString) {
        paramString = i(paramString);
        if (paramString == null || paramString.length() <= 2) {
            return paramString;
        }
        StrBuilder strBuilder = new StrBuilder(paramString.length());
        for (byte b1 = 0; b1 < paramString.length(); b1++) {
            char c1 = paramString.charAt(b1);
            if (Character.isWhitespace(c1)) {
                if (b1 > 0 && !Character.isWhitespace(paramString.charAt(b1 - 1))) {
                    strBuilder.append(' ');
                }
            } else {
                strBuilder.append(c1);
            }
        }
        return strBuilder.toString();
    }
}
